home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / controls / Button.as next >
Encoding:
Text File  |  2009-02-12  |  50.0 KB  |  1,529 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.FocusEvent;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.MouseEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.text.TextLineMetrics;
  10.    import flash.ui.Keyboard;
  11.    import flash.utils.Timer;
  12.    import mx.controls.dataGridClasses.DataGridListData;
  13.    import mx.controls.listClasses.BaseListData;
  14.    import mx.controls.listClasses.IDropInListItemRenderer;
  15.    import mx.controls.listClasses.IListItemRenderer;
  16.    import mx.core.EdgeMetrics;
  17.    import mx.core.FlexVersion;
  18.    import mx.core.IBorder;
  19.    import mx.core.IButton;
  20.    import mx.core.IDataRenderer;
  21.    import mx.core.IFlexAsset;
  22.    import mx.core.IFlexDisplayObject;
  23.    import mx.core.IFlexModuleFactory;
  24.    import mx.core.IFontContextComponent;
  25.    import mx.core.IInvalidating;
  26.    import mx.core.IProgrammaticSkin;
  27.    import mx.core.IRectangularBorder;
  28.    import mx.core.IStateClient;
  29.    import mx.core.IUIComponent;
  30.    import mx.core.IUITextField;
  31.    import mx.core.UIComponent;
  32.    import mx.core.UITextField;
  33.    import mx.core.mx_internal;
  34.    import mx.events.FlexEvent;
  35.    import mx.events.MoveEvent;
  36.    import mx.managers.IFocusManagerComponent;
  37.    import mx.styles.ISimpleStyleClient;
  38.    
  39.    use namespace mx_internal;
  40.    
  41.    public class Button extends UIComponent implements IDataRenderer, IDropInListItemRenderer, IFocusManagerComponent, IListItemRenderer, IFontContextComponent, IButton
  42.    {
  43.       mx_internal static var createAccessibilityImplementation:Function;
  44.       
  45.       mx_internal static const VERSION:String = "3.0.0.0";
  46.       
  47.       mx_internal static var TEXT_WIDTH_PADDING:Number = UITextField.mx_internal::TEXT_WIDTH_PADDING + 1;
  48.       
  49.       mx_internal var _emphasized:Boolean = false;
  50.       
  51.       mx_internal var extraSpacing:Number = 20;
  52.       
  53.       private var icons:Array;
  54.       
  55.       public var selectedField:String = null;
  56.       
  57.       private var labelChanged:Boolean = false;
  58.       
  59.       private var skinMeasuredWidth:Number;
  60.       
  61.       mx_internal var checkedDefaultSkin:Boolean = false;
  62.       
  63.       private var autoRepeatTimer:Timer;
  64.       
  65.       mx_internal var disabledIconName:String = "disabledIcon";
  66.       
  67.       mx_internal var disabledSkinName:String = "disabledSkin";
  68.       
  69.       mx_internal var checkedDefaultIcon:Boolean = false;
  70.       
  71.       public var stickyHighlighting:Boolean = false;
  72.       
  73.       private var enabledChanged:Boolean = false;
  74.       
  75.       mx_internal var selectedUpIconName:String = "selectedUpIcon";
  76.       
  77.       mx_internal var selectedUpSkinName:String = "selectedUpSkin";
  78.       
  79.       mx_internal var upIconName:String = "upIcon";
  80.       
  81.       mx_internal var upSkinName:String = "upSkin";
  82.       
  83.       mx_internal var centerContent:Boolean = true;
  84.       
  85.       mx_internal var buttonOffset:Number = 0;
  86.       
  87.       private var skinMeasuredHeight:Number;
  88.       
  89.       private var oldUnscaledWidth:Number;
  90.       
  91.       mx_internal var downIconName:String = "downIcon";
  92.       
  93.       mx_internal var _labelPlacement:String = "right";
  94.       
  95.       mx_internal var downSkinName:String = "downSkin";
  96.       
  97.       mx_internal var _toggle:Boolean = false;
  98.       
  99.       private var _phase:String = "up";
  100.       
  101.       private var toolTipSet:Boolean = false;
  102.       
  103.       private var _data:Object;
  104.       
  105.       mx_internal var currentIcon:IFlexDisplayObject;
  106.       
  107.       mx_internal var currentSkin:IFlexDisplayObject;
  108.       
  109.       mx_internal var overIconName:String = "overIcon";
  110.       
  111.       mx_internal var selectedDownIconName:String = "selectedDownIcon";
  112.       
  113.       mx_internal var overSkinName:String = "overSkin";
  114.       
  115.       mx_internal var iconName:String = "icon";
  116.       
  117.       mx_internal var skinName:String = "skin";
  118.       
  119.       mx_internal var selectedDownSkinName:String = "selectedDownSkin";
  120.       
  121.       private var skins:Array;
  122.       
  123.       private var selectedSet:Boolean;
  124.       
  125.       private var _autoRepeat:Boolean = false;
  126.       
  127.       private var styleChangedFlag:Boolean = true;
  128.       
  129.       mx_internal var selectedOverIconName:String = "selectedOverIcon";
  130.       
  131.       private var _listData:BaseListData;
  132.       
  133.       mx_internal var selectedOverSkinName:String = "selectedOverSkin";
  134.       
  135.       protected var textField:IUITextField;
  136.       
  137.       private var labelSet:Boolean;
  138.       
  139.       mx_internal var defaultIconUsesStates:Boolean = false;
  140.       
  141.       mx_internal var defaultSkinUsesStates:Boolean = false;
  142.       
  143.       mx_internal var toggleChanged:Boolean = false;
  144.       
  145.       private var emphasizedChanged:Boolean = false;
  146.       
  147.       private var _label:String = "";
  148.       
  149.       mx_internal var _selected:Boolean = false;
  150.       
  151.       mx_internal var selectedDisabledIconName:String = "selectedDisabledIcon";
  152.       
  153.       mx_internal var selectedDisabledSkinName:String = "selectedDisabledSkin";
  154.       
  155.       public function Button()
  156.       {
  157.          skins = [];
  158.          icons = [];
  159.          super();
  160.          mouseChildren = false;
  161.          addEventListener(MouseEvent.ROLL_OVER,rollOverHandler);
  162.          addEventListener(MouseEvent.ROLL_OUT,rollOutHandler);
  163.          addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  164.          addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler);
  165.          addEventListener(MouseEvent.CLICK,clickHandler);
  166.       }
  167.       
  168.       private function previousVersion_measure() : void
  169.       {
  170.          var iconHeight:Number;
  171.          var iconWidth:Number;
  172.          var textWidth:Number;
  173.          var tempCurrentIcon:IFlexDisplayObject;
  174.          var h:Number;
  175.          var textHeight:Number;
  176.          var w:Number;
  177.          var bm:EdgeMetrics = null;
  178.          var lineMetrics:TextLineMetrics = null;
  179.          var paddingLeft:Number = NaN;
  180.          var paddingRight:Number = NaN;
  181.          var paddingTop:Number = NaN;
  182.          var paddingBottom:Number = NaN;
  183.          var horizontalGap:Number = NaN;
  184.          super.measure();
  185.          textWidth = 0;
  186.          textHeight = 0;
  187.          if(label)
  188.          {
  189.             lineMetrics = measureText(label);
  190.             textWidth = lineMetrics.width;
  191.             textHeight = lineMetrics.height;
  192.             paddingLeft = getStyle("paddingLeft");
  193.             paddingRight = getStyle("paddingRight");
  194.             paddingTop = getStyle("paddingTop");
  195.             paddingBottom = getStyle("paddingBottom");
  196.             textWidth += paddingLeft + paddingRight + getStyle("textIndent");
  197.             textHeight += paddingTop + paddingBottom;
  198.          }
  199.          try
  200.          {
  201.             bm = mx_internal::currentSkin["borderMetrics"];
  202.          }
  203.          catch(e:Error)
  204.          {
  205.             bm = new EdgeMetrics(3,3,3,3);
  206.          }
  207.          tempCurrentIcon = mx_internal::getCurrentIcon();
  208.          iconWidth = !!tempCurrentIcon ? Number(tempCurrentIcon.width) : 0;
  209.          iconHeight = !!tempCurrentIcon ? Number(tempCurrentIcon.height) : 0;
  210.          w = 0;
  211.          h = 0;
  212.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  213.          {
  214.             w = textWidth + iconWidth;
  215.             if(iconWidth != 0)
  216.             {
  217.                horizontalGap = getStyle("horizontalGap");
  218.                w += horizontalGap - 2;
  219.             }
  220.             h = Math.max(textHeight,iconHeight + 6);
  221.          }
  222.          else
  223.          {
  224.             w = Math.max(textWidth,iconWidth);
  225.             h = textHeight + iconHeight;
  226.             if(iconHeight != 0)
  227.             {
  228.                h += getStyle("verticalGap");
  229.             }
  230.          }
  231.          if(bm)
  232.          {
  233.             w += bm.left + bm.right;
  234.             h += bm.top + bm.bottom;
  235.          }
  236.          if(Boolean(label) && label.length != 0)
  237.          {
  238.             w += mx_internal::extraSpacing;
  239.          }
  240.          else
  241.          {
  242.             w += 6;
  243.          }
  244.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  245.          {
  246.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  247.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  248.          }
  249.          if(!isNaN(skinMeasuredWidth))
  250.          {
  251.             w = Math.max(skinMeasuredWidth,w);
  252.          }
  253.          if(!isNaN(skinMeasuredHeight))
  254.          {
  255.             h = Math.max(skinMeasuredHeight,h);
  256.          }
  257.          measuredMinWidth = measuredWidth = w;
  258.          measuredMinHeight = measuredHeight = h;
  259.       }
  260.       
  261.       [Bindable("labelChanged")]
  262.       public function get label() : String
  263.       {
  264.          return _label;
  265.       }
  266.       
  267.       mx_internal function getCurrentIconName() : String
  268.       {
  269.          var _loc1_:String = null;
  270.          if(!enabled)
  271.          {
  272.             _loc1_ = selected ? mx_internal::selectedDisabledIconName : mx_internal::disabledIconName;
  273.          }
  274.          else if(mx_internal::phase == ButtonPhase.UP)
  275.          {
  276.             _loc1_ = selected ? mx_internal::selectedUpIconName : mx_internal::upIconName;
  277.          }
  278.          else if(mx_internal::phase == ButtonPhase.OVER)
  279.          {
  280.             _loc1_ = selected ? mx_internal::selectedOverIconName : mx_internal::overIconName;
  281.          }
  282.          else if(mx_internal::phase == ButtonPhase.DOWN)
  283.          {
  284.             _loc1_ = selected ? mx_internal::selectedDownIconName : mx_internal::downIconName;
  285.          }
  286.          return _loc1_;
  287.       }
  288.       
  289.       protected function mouseUpHandler(param1:MouseEvent) : void
  290.       {
  291.          if(!enabled)
  292.          {
  293.             return;
  294.          }
  295.          mx_internal::phase = ButtonPhase.OVER;
  296.          mx_internal::buttonReleased();
  297.          if(!toggle)
  298.          {
  299.             param1.updateAfterEvent();
  300.          }
  301.       }
  302.       
  303.       override protected function adjustFocusRect(param1:DisplayObject = null) : void
  304.       {
  305.          super.adjustFocusRect(!mx_internal::currentSkin ? DisplayObject(mx_internal::currentIcon) : this);
  306.       }
  307.       
  308.       mx_internal function set phase(param1:String) : void
  309.       {
  310.          _phase = param1;
  311.          invalidateSize();
  312.          invalidateDisplayList();
  313.       }
  314.       
  315.       mx_internal function viewIconForPhase(param1:String) : IFlexDisplayObject
  316.       {
  317.          var _loc3_:IFlexDisplayObject = null;
  318.          var _loc4_:Boolean = false;
  319.          var _loc5_:String = null;
  320.          var _loc2_:Class = Class(getStyle(param1));
  321.          if(!_loc2_)
  322.          {
  323.             _loc2_ = Class(getStyle(mx_internal::iconName));
  324.             if(mx_internal::defaultIconUsesStates)
  325.             {
  326.                param1 = mx_internal::iconName;
  327.             }
  328.             if(!mx_internal::checkedDefaultIcon && Boolean(_loc2_))
  329.             {
  330.                _loc3_ = IFlexDisplayObject(new _loc2_());
  331.                if(!(_loc3_ is IProgrammaticSkin) && _loc3_ is IStateClient)
  332.                {
  333.                   mx_internal::defaultIconUsesStates = true;
  334.                   param1 = mx_internal::iconName;
  335.                }
  336.                if(_loc3_)
  337.                {
  338.                   mx_internal::checkedDefaultIcon = true;
  339.                }
  340.             }
  341.          }
  342.          _loc3_ = IFlexDisplayObject(getChildByName(param1));
  343.          if(_loc3_ == null)
  344.          {
  345.             if(_loc2_ != null)
  346.             {
  347.                _loc3_ = IFlexDisplayObject(new _loc2_());
  348.                _loc3_.name = param1;
  349.                if(_loc3_ is ISimpleStyleClient)
  350.                {
  351.                   ISimpleStyleClient(_loc3_).styleName = this;
  352.                }
  353.                addChild(DisplayObject(_loc3_));
  354.                _loc4_ = false;
  355.                if(_loc3_ is IInvalidating)
  356.                {
  357.                   IInvalidating(_loc3_).validateNow();
  358.                   _loc4_ = true;
  359.                }
  360.                else if(_loc3_ is IProgrammaticSkin)
  361.                {
  362.                   IProgrammaticSkin(_loc3_).validateDisplayList();
  363.                   _loc4_ = true;
  364.                }
  365.                if(Boolean(_loc3_) && _loc3_ is IUIComponent)
  366.                {
  367.                   IUIComponent(_loc3_).enabled = enabled;
  368.                }
  369.                if(_loc4_)
  370.                {
  371.                   _loc3_.setActualSize(_loc3_.measuredWidth,_loc3_.measuredHeight);
  372.                }
  373.                icons.push(_loc3_);
  374.             }
  375.          }
  376.          if(mx_internal::currentIcon != null)
  377.          {
  378.             mx_internal::currentIcon.visible = false;
  379.          }
  380.          mx_internal::currentIcon = _loc3_;
  381.          if(mx_internal::defaultIconUsesStates && mx_internal::currentIcon is IStateClient)
  382.          {
  383.             _loc5_ = "";
  384.             if(!enabled)
  385.             {
  386.                _loc5_ = selected ? "selectedDisabled" : "disabled";
  387.             }
  388.             else if(mx_internal::phase == ButtonPhase.UP)
  389.             {
  390.                _loc5_ = selected ? "selectedUp" : "up";
  391.             }
  392.             else if(mx_internal::phase == ButtonPhase.OVER)
  393.             {
  394.                _loc5_ = selected ? "selectedOver" : "over";
  395.             }
  396.             else if(mx_internal::phase == ButtonPhase.DOWN)
  397.             {
  398.                _loc5_ = selected ? "selectedDown" : "down";
  399.             }
  400.             IStateClient(mx_internal::currentIcon).currentState = _loc5_;
  401.          }
  402.          if(mx_internal::currentIcon != null)
  403.          {
  404.             mx_internal::currentIcon.visible = true;
  405.          }
  406.          return _loc3_;
  407.       }
  408.       
  409.       mx_internal function viewSkinForPhase(param1:String, param2:String) : void
  410.       {
  411.          var _loc4_:IFlexDisplayObject = null;
  412.          var _loc5_:Number = NaN;
  413.          var _loc6_:ISimpleStyleClient = null;
  414.          var _loc3_:Class = Class(getStyle(param1));
  415.          if(!_loc3_)
  416.          {
  417.             _loc3_ = Class(getStyle(mx_internal::skinName));
  418.             if(mx_internal::defaultSkinUsesStates)
  419.             {
  420.                param1 = mx_internal::skinName;
  421.             }
  422.             if(!mx_internal::checkedDefaultSkin && Boolean(_loc3_))
  423.             {
  424.                _loc4_ = IFlexDisplayObject(new _loc3_());
  425.                if(!(_loc4_ is IProgrammaticSkin) && _loc4_ is IStateClient)
  426.                {
  427.                   mx_internal::defaultSkinUsesStates = true;
  428.                   param1 = mx_internal::skinName;
  429.                }
  430.                if(_loc4_)
  431.                {
  432.                   mx_internal::checkedDefaultSkin = true;
  433.                }
  434.             }
  435.          }
  436.          _loc4_ = IFlexDisplayObject(getChildByName(param1));
  437.          if(!_loc4_)
  438.          {
  439.             if(_loc3_)
  440.             {
  441.                _loc4_ = IFlexDisplayObject(new _loc3_());
  442.                _loc4_.name = param1;
  443.                _loc6_ = _loc4_ as ISimpleStyleClient;
  444.                if(_loc6_)
  445.                {
  446.                   _loc6_.styleName = this;
  447.                }
  448.                addChild(DisplayObject(_loc4_));
  449.                _loc4_.setActualSize(unscaledWidth,unscaledHeight);
  450.                if(_loc4_ is IInvalidating && initialized)
  451.                {
  452.                   IInvalidating(_loc4_).validateNow();
  453.                }
  454.                else if(_loc4_ is IProgrammaticSkin && initialized)
  455.                {
  456.                   IProgrammaticSkin(_loc4_).validateDisplayList();
  457.                }
  458.                skins.push(_loc4_);
  459.             }
  460.          }
  461.          if(mx_internal::currentSkin)
  462.          {
  463.             mx_internal::currentSkin.visible = false;
  464.          }
  465.          mx_internal::currentSkin = _loc4_;
  466.          if(mx_internal::defaultSkinUsesStates && mx_internal::currentSkin is IStateClient)
  467.          {
  468.             IStateClient(mx_internal::currentSkin).currentState = param2;
  469.          }
  470.          if(mx_internal::currentSkin)
  471.          {
  472.             mx_internal::currentSkin.visible = true;
  473.          }
  474.          if(enabled)
  475.          {
  476.             if(mx_internal::phase == ButtonPhase.OVER)
  477.             {
  478.                _loc5_ = textField.getStyle("textRollOverColor");
  479.             }
  480.             else if(mx_internal::phase == ButtonPhase.DOWN)
  481.             {
  482.                _loc5_ = textField.getStyle("textSelectedColor");
  483.             }
  484.             else
  485.             {
  486.                _loc5_ = textField.getStyle("color");
  487.             }
  488.             textField.setColor(_loc5_);
  489.          }
  490.       }
  491.       
  492.       mx_internal function getTextField() : IUITextField
  493.       {
  494.          return textField;
  495.       }
  496.       
  497.       protected function rollOverHandler(param1:MouseEvent) : void
  498.       {
  499.          if(mx_internal::phase == ButtonPhase.UP)
  500.          {
  501.             if(param1.buttonDown)
  502.             {
  503.                return;
  504.             }
  505.             mx_internal::phase = ButtonPhase.OVER;
  506.             param1.updateAfterEvent();
  507.          }
  508.          else if(mx_internal::phase == ButtonPhase.OVER)
  509.          {
  510.             mx_internal::phase = ButtonPhase.DOWN;
  511.             param1.updateAfterEvent();
  512.             if(autoRepeatTimer)
  513.             {
  514.                autoRepeatTimer.start();
  515.             }
  516.          }
  517.       }
  518.       
  519.       override protected function createChildren() : void
  520.       {
  521.          super.createChildren();
  522.          if(!textField)
  523.          {
  524.             textField = IUITextField(createInFontContext(UITextField));
  525.             textField.styleName = this;
  526.             addChild(DisplayObject(textField));
  527.          }
  528.       }
  529.       
  530.       mx_internal function setSelected(param1:Boolean, param2:Boolean = false) : void
  531.       {
  532.          if(mx_internal::_selected != param1)
  533.          {
  534.             mx_internal::_selected = param1;
  535.             invalidateDisplayList();
  536.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  537.             {
  538.                if(toggle)
  539.                {
  540.                   dispatchEvent(new Event(Event.CHANGE));
  541.                }
  542.             }
  543.             else if(toggle && !param2)
  544.             {
  545.                dispatchEvent(new Event(Event.CHANGE));
  546.             }
  547.             dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  548.          }
  549.       }
  550.       
  551.       private function autoRepeatTimer_timerDelayHandler(param1:Event) : void
  552.       {
  553.          if(!enabled)
  554.          {
  555.             return;
  556.          }
  557.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  558.          if(autoRepeat)
  559.          {
  560.             autoRepeatTimer.reset();
  561.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  562.             autoRepeatTimer.delay = getStyle("repeatInterval");
  563.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  564.             autoRepeatTimer.start();
  565.          }
  566.       }
  567.       
  568.       public function get autoRepeat() : Boolean
  569.       {
  570.          return _autoRepeat;
  571.       }
  572.       
  573.       public function set selected(param1:Boolean) : void
  574.       {
  575.          selectedSet = true;
  576.          mx_internal::setSelected(param1,true);
  577.       }
  578.       
  579.       override protected function focusOutHandler(param1:FocusEvent) : void
  580.       {
  581.          super.focusOutHandler(param1);
  582.          if(mx_internal::phase != ButtonPhase.UP)
  583.          {
  584.             mx_internal::phase = ButtonPhase.UP;
  585.          }
  586.       }
  587.       
  588.       [Bindable("labelPlacementChanged")]
  589.       public function get labelPlacement() : String
  590.       {
  591.          return mx_internal::_labelPlacement;
  592.       }
  593.       
  594.       public function set autoRepeat(param1:Boolean) : void
  595.       {
  596.          _autoRepeat = param1;
  597.          if(param1)
  598.          {
  599.             autoRepeatTimer = new Timer(1);
  600.          }
  601.          else
  602.          {
  603.             autoRepeatTimer = null;
  604.          }
  605.       }
  606.       
  607.       mx_internal function changeIcons() : void
  608.       {
  609.          var _loc1_:int = int(icons.length);
  610.          var _loc2_:int = 0;
  611.          while(_loc2_ < _loc1_)
  612.          {
  613.             removeChild(icons[_loc2_]);
  614.             _loc2_++;
  615.          }
  616.          icons = [];
  617.          mx_internal::checkedDefaultIcon = false;
  618.          mx_internal::defaultIconUsesStates = false;
  619.       }
  620.       
  621.       public function set data(param1:Object) : void
  622.       {
  623.          var _loc2_:* = undefined;
  624.          var _loc3_:* = undefined;
  625.          _data = param1;
  626.          if(Boolean(_listData) && _listData is DataGridListData)
  627.          {
  628.             _loc2_ = _data[DataGridListData(_listData).dataField];
  629.             _loc3_ = "";
  630.          }
  631.          else if(_listData)
  632.          {
  633.             if(selectedField)
  634.             {
  635.                _loc2_ = _data[selectedField];
  636.             }
  637.             _loc3_ = _listData.label;
  638.          }
  639.          else
  640.          {
  641.             _loc2_ = _data;
  642.          }
  643.          if(_loc2_ !== undefined && !selectedSet)
  644.          {
  645.             selected = _loc2_ as Boolean;
  646.             selectedSet = false;
  647.          }
  648.          if(_loc3_ !== undefined && !labelSet)
  649.          {
  650.             label = _loc3_;
  651.             labelSet = false;
  652.          }
  653.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  654.       }
  655.       
  656.       mx_internal function getCurrentIcon() : IFlexDisplayObject
  657.       {
  658.          var _loc1_:String = mx_internal::getCurrentIconName();
  659.          if(!_loc1_)
  660.          {
  661.             return null;
  662.          }
  663.          return mx_internal::viewIconForPhase(_loc1_);
  664.       }
  665.       
  666.       public function get fontContext() : IFlexModuleFactory
  667.       {
  668.          return moduleFactory;
  669.       }
  670.       
  671.       public function get emphasized() : Boolean
  672.       {
  673.          return mx_internal::_emphasized;
  674.       }
  675.       
  676.       [Bindable("dataChange")]
  677.       public function get listData() : BaseListData
  678.       {
  679.          return _listData;
  680.       }
  681.       
  682.       mx_internal function layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  683.       {
  684.          var _loc20_:TextLineMetrics = null;
  685.          var _loc28_:MoveEvent = null;
  686.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  687.          {
  688.             previousVersion_layoutContents(param1,param2,param3);
  689.             return;
  690.          }
  691.          var _loc4_:Number = 0;
  692.          var _loc5_:Number = 0;
  693.          var _loc6_:Number = 0;
  694.          var _loc7_:Number = 0;
  695.          var _loc8_:Number = 0;
  696.          var _loc9_:Number = 0;
  697.          var _loc10_:Number = 0;
  698.          var _loc11_:Number = 0;
  699.          var _loc12_:Number = 0;
  700.          var _loc13_:Number = 0;
  701.          var _loc14_:Number = getStyle("paddingLeft");
  702.          var _loc15_:Number = getStyle("paddingRight");
  703.          var _loc16_:Number = getStyle("paddingTop");
  704.          var _loc17_:Number = getStyle("paddingBottom");
  705.          var _loc18_:Number = 0;
  706.          var _loc19_:Number = 0;
  707.          if(label)
  708.          {
  709.             _loc20_ = measureText(label);
  710.             _loc18_ = _loc20_.width + mx_internal::TEXT_WIDTH_PADDING;
  711.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  712.          }
  713.          else
  714.          {
  715.             _loc20_ = measureText("Wj");
  716.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  717.          }
  718.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  719.          var _loc22_:String = getStyle("textAlign");
  720.          var _loc23_:Number = param1;
  721.          var _loc24_:Number = param2;
  722.          var _loc25_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  723.          if(_loc25_)
  724.          {
  725.             _loc23_ -= _loc25_.left + _loc25_.right;
  726.             _loc24_ -= _loc25_.top + _loc25_.bottom;
  727.          }
  728.          if(mx_internal::currentIcon)
  729.          {
  730.             _loc8_ = Number(mx_internal::currentIcon.width);
  731.             _loc9_ = Number(mx_internal::currentIcon.height);
  732.          }
  733.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  734.          {
  735.             _loc12_ = getStyle("horizontalGap");
  736.             if(_loc8_ == 0 || _loc18_ == 0)
  737.             {
  738.                _loc12_ = 0;
  739.             }
  740.             if(_loc18_ > 0)
  741.             {
  742.                textField.width = _loc4_ = Math.max(Math.min(_loc23_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,_loc18_),0);
  743.             }
  744.             else
  745.             {
  746.                textField.width = _loc4_ = 0;
  747.             }
  748.             textField.height = _loc5_ = Math.min(_loc24_,_loc19_);
  749.             if(_loc22_ == "left")
  750.             {
  751.                _loc6_ += _loc14_;
  752.             }
  753.             else if(_loc22_ == "right")
  754.             {
  755.                _loc6_ += _loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  756.             }
  757.             else
  758.             {
  759.                _loc6_ += (_loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc14_ - _loc15_) / 2 + _loc14_;
  760.             }
  761.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  762.             {
  763.                _loc6_ += _loc8_ + _loc12_;
  764.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  765.             }
  766.             else
  767.             {
  768.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  769.             }
  770.             _loc11_ = (_loc24_ - _loc9_ - _loc16_ - _loc17_) / 2 + _loc16_;
  771.             _loc7_ = (_loc24_ - _loc5_ - _loc16_ - _loc17_) / 2 + _loc16_;
  772.          }
  773.          else
  774.          {
  775.             _loc13_ = getStyle("verticalGap");
  776.             if(_loc9_ == 0 || label == "")
  777.             {
  778.                _loc13_ = 0;
  779.             }
  780.             if(_loc18_ > 0)
  781.             {
  782.                textField.width = _loc4_ = Math.max(_loc23_ - _loc14_ - _loc15_,0);
  783.                textField.height = _loc5_ = Math.min(_loc24_ - _loc9_ - _loc16_ - _loc17_ - _loc13_,_loc19_);
  784.             }
  785.             else
  786.             {
  787.                textField.width = _loc4_ = 0;
  788.                textField.height = _loc5_ = 0;
  789.             }
  790.             _loc6_ = _loc14_;
  791.             if(_loc22_ == "left")
  792.             {
  793.                _loc10_ += _loc14_;
  794.             }
  795.             else if(_loc22_ == "right")
  796.             {
  797.                _loc10_ += Math.max(_loc23_ - _loc8_ - _loc15_,_loc14_);
  798.             }
  799.             else
  800.             {
  801.                _loc10_ += (_loc23_ - _loc8_ - _loc14_ - _loc15_) / 2 + _loc14_;
  802.             }
  803.             if(labelPlacement == ButtonLabelPlacement.TOP)
  804.             {
  805.                _loc7_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  806.                _loc11_ += _loc7_ + _loc5_ + _loc13_;
  807.             }
  808.             else
  809.             {
  810.                _loc11_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  811.                _loc7_ += _loc11_ + _loc9_ + _loc13_;
  812.             }
  813.          }
  814.          var _loc26_:Number = _loc21_;
  815.          var _loc27_:Number = _loc21_;
  816.          if(_loc25_)
  817.          {
  818.             _loc26_ += _loc25_.left;
  819.             _loc27_ += _loc25_.top;
  820.          }
  821.          textField.x = Math.round(_loc6_ + _loc26_);
  822.          textField.y = Math.round(_loc7_ + _loc27_);
  823.          if(mx_internal::currentIcon)
  824.          {
  825.             _loc10_ += _loc26_;
  826.             _loc11_ += _loc27_;
  827.             _loc28_ = new MoveEvent(MoveEvent.MOVE);
  828.             _loc28_.oldX = mx_internal::currentIcon.x;
  829.             _loc28_.oldY = mx_internal::currentIcon.y;
  830.             mx_internal::currentIcon.x = Math.round(_loc10_);
  831.             mx_internal::currentIcon.y = Math.round(_loc11_);
  832.             mx_internal::currentIcon.dispatchEvent(_loc28_);
  833.          }
  834.          if(mx_internal::currentSkin)
  835.          {
  836.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  837.          }
  838.          if(mx_internal::currentIcon)
  839.          {
  840.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  841.          }
  842.          if(textField)
  843.          {
  844.             setChildIndex(DisplayObject(textField),numChildren - 1);
  845.          }
  846.       }
  847.       
  848.       protected function mouseDownHandler(param1:MouseEvent) : void
  849.       {
  850.          if(!enabled)
  851.          {
  852.             return;
  853.          }
  854.          systemManager.addEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  855.          systemManager.stage.addEventListener(Event.MOUSE_LEAVE,stage_mouseLeaveHandler);
  856.          mx_internal::buttonPressed();
  857.          param1.updateAfterEvent();
  858.       }
  859.       
  860.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  861.       {
  862.          if(!enabled)
  863.          {
  864.             return;
  865.          }
  866.          if(param1.keyCode == Keyboard.SPACE)
  867.          {
  868.             mx_internal::buttonPressed();
  869.          }
  870.       }
  871.       
  872.       protected function rollOutHandler(param1:MouseEvent) : void
  873.       {
  874.          if(mx_internal::phase == ButtonPhase.OVER)
  875.          {
  876.             mx_internal::phase = ButtonPhase.UP;
  877.             param1.updateAfterEvent();
  878.          }
  879.          else if(mx_internal::phase == ButtonPhase.DOWN && !stickyHighlighting)
  880.          {
  881.             mx_internal::phase = ButtonPhase.OVER;
  882.             param1.updateAfterEvent();
  883.             if(autoRepeatTimer)
  884.             {
  885.                autoRepeatTimer.stop();
  886.             }
  887.          }
  888.       }
  889.       
  890.       mx_internal function get phase() : String
  891.       {
  892.          return _phase;
  893.       }
  894.       
  895.       override public function set enabled(param1:Boolean) : void
  896.       {
  897.          if(super.enabled == param1)
  898.          {
  899.             return;
  900.          }
  901.          super.enabled = param1;
  902.          enabledChanged = true;
  903.          invalidateProperties();
  904.          invalidateDisplayList();
  905.       }
  906.       
  907.       override protected function measure() : void
  908.       {
  909.          var _loc9_:TextLineMetrics = null;
  910.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  911.          {
  912.             previousVersion_measure();
  913.             return;
  914.          }
  915.          super.measure();
  916.          var _loc1_:Number = 0;
  917.          var _loc2_:Number = 0;
  918.          if(label)
  919.          {
  920.             _loc9_ = measureText(label);
  921.             _loc1_ = _loc9_.width + mx_internal::TEXT_WIDTH_PADDING;
  922.             _loc2_ = _loc9_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  923.          }
  924.          var _loc3_:IFlexDisplayObject = mx_internal::getCurrentIcon();
  925.          var _loc4_:Number = !!_loc3_ ? Number(_loc3_.width) : 0;
  926.          var _loc5_:Number = !!_loc3_ ? Number(_loc3_.height) : 0;
  927.          var _loc6_:Number = 0;
  928.          var _loc7_:Number = 0;
  929.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  930.          {
  931.             _loc6_ = _loc1_ + _loc4_;
  932.             if(Boolean(_loc1_) && Boolean(_loc4_))
  933.             {
  934.                _loc6_ += getStyle("horizontalGap");
  935.             }
  936.             _loc7_ = Math.max(_loc2_,_loc5_);
  937.          }
  938.          else
  939.          {
  940.             _loc6_ = Math.max(_loc1_,_loc4_);
  941.             _loc7_ = _loc2_ + _loc5_;
  942.             if(Boolean(_loc2_) && Boolean(_loc5_))
  943.             {
  944.                _loc7_ += getStyle("verticalGap");
  945.             }
  946.          }
  947.          if(Boolean(_loc1_) || Boolean(_loc4_))
  948.          {
  949.             _loc6_ += getStyle("paddingLeft") + getStyle("paddingRight");
  950.             _loc7_ += getStyle("paddingTop") + getStyle("paddingBottom");
  951.          }
  952.          var _loc8_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  953.          if(_loc8_)
  954.          {
  955.             _loc6_ += _loc8_.left + _loc8_.right;
  956.             _loc7_ += _loc8_.top + _loc8_.bottom;
  957.          }
  958.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  959.          {
  960.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  961.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  962.          }
  963.          if(!isNaN(skinMeasuredWidth))
  964.          {
  965.             _loc6_ = Math.max(skinMeasuredWidth,_loc6_);
  966.          }
  967.          if(!isNaN(skinMeasuredHeight))
  968.          {
  969.             _loc7_ = Math.max(skinMeasuredHeight,_loc7_);
  970.          }
  971.          measuredMinWidth = measuredWidth = _loc6_;
  972.          measuredMinHeight = measuredHeight = _loc7_;
  973.       }
  974.       
  975.       [Bindable("toggleChanged")]
  976.       public function get toggle() : Boolean
  977.       {
  978.          return mx_internal::_toggle;
  979.       }
  980.       
  981.       mx_internal function buttonReleased() : void
  982.       {
  983.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  984.          systemManager.stage.removeEventListener(Event.MOUSE_LEAVE,stage_mouseLeaveHandler);
  985.          if(autoRepeatTimer)
  986.          {
  987.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  988.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  989.             autoRepeatTimer.reset();
  990.          }
  991.       }
  992.       
  993.       mx_internal function buttonPressed() : void
  994.       {
  995.          mx_internal::phase = ButtonPhase.DOWN;
  996.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  997.          if(autoRepeat)
  998.          {
  999.             autoRepeatTimer.delay = getStyle("repeatDelay");
  1000.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  1001.             autoRepeatTimer.start();
  1002.          }
  1003.       }
  1004.       
  1005.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  1006.       {
  1007.          if(!enabled)
  1008.          {
  1009.             return;
  1010.          }
  1011.          if(param1.keyCode == Keyboard.SPACE)
  1012.          {
  1013.             mx_internal::buttonReleased();
  1014.             if(mx_internal::phase == ButtonPhase.DOWN)
  1015.             {
  1016.                dispatchEvent(new MouseEvent(MouseEvent.CLICK));
  1017.             }
  1018.             mx_internal::phase = ButtonPhase.UP;
  1019.          }
  1020.       }
  1021.       
  1022.       [Bindable("valueCommit")]
  1023.       [Bindable("click")]
  1024.       public function get selected() : Boolean
  1025.       {
  1026.          return mx_internal::_selected;
  1027.       }
  1028.       
  1029.       public function set labelPlacement(param1:String) : void
  1030.       {
  1031.          mx_internal::_labelPlacement = param1;
  1032.          invalidateSize();
  1033.          invalidateDisplayList();
  1034.          dispatchEvent(new Event("labelPlacementChanged"));
  1035.       }
  1036.       
  1037.       protected function clickHandler(param1:MouseEvent) : void
  1038.       {
  1039.          if(!enabled)
  1040.          {
  1041.             param1.stopImmediatePropagation();
  1042.             return;
  1043.          }
  1044.          if(toggle)
  1045.          {
  1046.             mx_internal::setSelected(!selected);
  1047.             param1.updateAfterEvent();
  1048.          }
  1049.       }
  1050.       
  1051.       override protected function initializeAccessibility() : void
  1052.       {
  1053.          if(Button.mx_internal::createAccessibilityImplementation != null)
  1054.          {
  1055.             Button.mx_internal::createAccessibilityImplementation(this);
  1056.          }
  1057.       }
  1058.       
  1059.       public function set toggle(param1:Boolean) : void
  1060.       {
  1061.          mx_internal::_toggle = param1;
  1062.          mx_internal::toggleChanged = true;
  1063.          invalidateProperties();
  1064.          invalidateDisplayList();
  1065.          dispatchEvent(new Event("toggleChanged"));
  1066.       }
  1067.       
  1068.       override public function get baselinePosition() : Number
  1069.       {
  1070.          var _loc1_:String = null;
  1071.          var _loc2_:TextLineMetrics = null;
  1072.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1073.          {
  1074.             _loc1_ = label;
  1075.             if(!_loc1_)
  1076.             {
  1077.                _loc1_ = "Wj";
  1078.             }
  1079.             validateNow();
  1080.             if(!label && (labelPlacement == ButtonLabelPlacement.TOP || labelPlacement == ButtonLabelPlacement.BOTTOM))
  1081.             {
  1082.                _loc2_ = measureText(_loc1_);
  1083.                return (measuredHeight - _loc2_.height) / 2 + _loc2_.ascent;
  1084.             }
  1085.             return textField.y + measureText(_loc1_).ascent;
  1086.          }
  1087.          if(!mx_internal::validateBaselinePosition())
  1088.          {
  1089.             return NaN;
  1090.          }
  1091.          return textField.y + textField.baselinePosition;
  1092.       }
  1093.       
  1094.       [Bindable("dataChange")]
  1095.       public function get data() : Object
  1096.       {
  1097.          return _data;
  1098.       }
  1099.       
  1100.       public function set fontContext(param1:IFlexModuleFactory) : void
  1101.       {
  1102.          this.moduleFactory = param1;
  1103.       }
  1104.       
  1105.       mx_internal function viewSkin() : void
  1106.       {
  1107.          var _loc1_:String = null;
  1108.          var _loc2_:String = null;
  1109.          if(!enabled)
  1110.          {
  1111.             _loc1_ = selected ? mx_internal::selectedDisabledSkinName : mx_internal::disabledSkinName;
  1112.             _loc2_ = selected ? "selectedDisabled" : "disabled";
  1113.          }
  1114.          else if(mx_internal::phase == ButtonPhase.UP)
  1115.          {
  1116.             _loc1_ = selected ? mx_internal::selectedUpSkinName : mx_internal::upSkinName;
  1117.             _loc2_ = selected ? "selectedUp" : "up";
  1118.          }
  1119.          else if(mx_internal::phase == ButtonPhase.OVER)
  1120.          {
  1121.             _loc1_ = selected ? mx_internal::selectedOverSkinName : mx_internal::overSkinName;
  1122.             _loc2_ = selected ? "selectedOver" : "over";
  1123.          }
  1124.          else if(mx_internal::phase == ButtonPhase.DOWN)
  1125.          {
  1126.             _loc1_ = selected ? mx_internal::selectedDownSkinName : mx_internal::downSkinName;
  1127.             _loc2_ = selected ? "selectedDown" : "down";
  1128.          }
  1129.          mx_internal::viewSkinForPhase(_loc1_,_loc2_);
  1130.       }
  1131.       
  1132.       override public function styleChanged(param1:String) : void
  1133.       {
  1134.          styleChangedFlag = true;
  1135.          super.styleChanged(param1);
  1136.          if(!param1 || param1 == "styleName")
  1137.          {
  1138.             mx_internal::changeSkins();
  1139.             mx_internal::changeIcons();
  1140.             if(initialized)
  1141.             {
  1142.                mx_internal::viewSkin();
  1143.                mx_internal::viewIcon();
  1144.             }
  1145.          }
  1146.          else if(param1.toLowerCase().indexOf("skin") != -1)
  1147.          {
  1148.             mx_internal::changeSkins();
  1149.          }
  1150.          else if(param1.toLowerCase().indexOf("icon") != -1)
  1151.          {
  1152.             mx_internal::changeIcons();
  1153.             invalidateSize();
  1154.          }
  1155.       }
  1156.       
  1157.       public function set emphasized(param1:Boolean) : void
  1158.       {
  1159.          mx_internal::_emphasized = param1;
  1160.          emphasizedChanged = true;
  1161.          invalidateDisplayList();
  1162.       }
  1163.       
  1164.       mx_internal function viewIcon() : void
  1165.       {
  1166.          var _loc1_:String = mx_internal::getCurrentIconName();
  1167.          mx_internal::viewIconForPhase(_loc1_);
  1168.       }
  1169.       
  1170.       override public function set toolTip(param1:String) : void
  1171.       {
  1172.          super.toolTip = param1;
  1173.          if(param1)
  1174.          {
  1175.             toolTipSet = true;
  1176.          }
  1177.          else
  1178.          {
  1179.             toolTipSet = false;
  1180.             invalidateDisplayList();
  1181.          }
  1182.       }
  1183.       
  1184.       override protected function commitProperties() : void
  1185.       {
  1186.          super.commitProperties();
  1187.          if(hasFontContextChanged() && textField != null)
  1188.          {
  1189.             removeChild(DisplayObject(textField));
  1190.             textField = null;
  1191.          }
  1192.          if(!textField)
  1193.          {
  1194.             textField = IUITextField(createInFontContext(UITextField));
  1195.             textField.styleName = this;
  1196.             addChild(DisplayObject(textField));
  1197.             enabledChanged = true;
  1198.             mx_internal::toggleChanged = true;
  1199.          }
  1200.          if(!initialized)
  1201.          {
  1202.             mx_internal::viewSkin();
  1203.             mx_internal::viewIcon();
  1204.          }
  1205.          if(enabledChanged)
  1206.          {
  1207.             textField.enabled = enabled;
  1208.             if(Boolean(mx_internal::currentIcon) && mx_internal::currentIcon is IUIComponent)
  1209.             {
  1210.                IUIComponent(mx_internal::currentIcon).enabled = enabled;
  1211.             }
  1212.             enabledChanged = false;
  1213.          }
  1214.          if(mx_internal::toggleChanged)
  1215.          {
  1216.             if(!toggle)
  1217.             {
  1218.                selected = false;
  1219.             }
  1220.             mx_internal::toggleChanged = false;
  1221.          }
  1222.       }
  1223.       
  1224.       mx_internal function changeSkins() : void
  1225.       {
  1226.          var _loc1_:int = int(skins.length);
  1227.          var _loc2_:int = 0;
  1228.          while(_loc2_ < _loc1_)
  1229.          {
  1230.             removeChild(skins[_loc2_]);
  1231.             _loc2_++;
  1232.          }
  1233.          skins = [];
  1234.          skinMeasuredWidth = NaN;
  1235.          skinMeasuredHeight = NaN;
  1236.          mx_internal::checkedDefaultSkin = false;
  1237.          mx_internal::defaultSkinUsesStates = false;
  1238.          if(initialized && FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  1239.          {
  1240.             mx_internal::viewSkin();
  1241.             invalidateSize();
  1242.          }
  1243.       }
  1244.       
  1245.       private function autoRepeatTimer_timerHandler(param1:Event) : void
  1246.       {
  1247.          if(!enabled)
  1248.          {
  1249.             return;
  1250.          }
  1251.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  1252.       }
  1253.       
  1254.       private function previousVersion_layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  1255.       {
  1256.          var _loc20_:TextLineMetrics = null;
  1257.          var _loc28_:Number = NaN;
  1258.          var _loc29_:MoveEvent = null;
  1259.          var _loc4_:Number = 0;
  1260.          var _loc5_:Number = 0;
  1261.          var _loc6_:Number = 0;
  1262.          var _loc7_:Number = 0;
  1263.          var _loc8_:Number = 0;
  1264.          var _loc9_:Number = 0;
  1265.          var _loc10_:Number = 0;
  1266.          var _loc11_:Number = 0;
  1267.          var _loc12_:Number = 2;
  1268.          var _loc13_:Number = 2;
  1269.          var _loc14_:Number = getStyle("paddingLeft");
  1270.          var _loc15_:Number = getStyle("paddingRight");
  1271.          var _loc16_:Number = getStyle("paddingTop");
  1272.          var _loc17_:Number = getStyle("paddingBottom");
  1273.          var _loc18_:Number = 0;
  1274.          var _loc19_:Number = 0;
  1275.          if(label)
  1276.          {
  1277.             _loc20_ = measureText(label);
  1278.             if(_loc20_.width > 0)
  1279.             {
  1280.                _loc18_ = _loc14_ + _loc15_ + getStyle("textIndent") + _loc20_.width;
  1281.             }
  1282.             _loc19_ = _loc20_.height;
  1283.          }
  1284.          else
  1285.          {
  1286.             _loc20_ = measureText("Wj");
  1287.             _loc19_ = _loc20_.height;
  1288.          }
  1289.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  1290.          var _loc22_:String = getStyle("textAlign");
  1291.          var _loc23_:EdgeMetrics = Boolean(mx_internal::currentSkin) && mx_internal::currentSkin is IRectangularBorder ? IRectangularBorder(mx_internal::currentSkin).borderMetrics : null;
  1292.          var _loc24_:Number = param1;
  1293.          var _loc25_:Number = param2 - _loc16_ - _loc17_;
  1294.          if(_loc23_)
  1295.          {
  1296.             _loc24_ -= _loc23_.left + _loc23_.right;
  1297.             _loc25_ -= _loc23_.top + _loc23_.bottom;
  1298.          }
  1299.          if(mx_internal::currentIcon)
  1300.          {
  1301.             _loc8_ = Number(mx_internal::currentIcon.width);
  1302.             _loc9_ = Number(mx_internal::currentIcon.height);
  1303.          }
  1304.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  1305.          {
  1306.             _loc12_ = getStyle("horizontalGap");
  1307.             if(_loc8_ == 0 || _loc18_ == 0)
  1308.             {
  1309.                _loc12_ = 0;
  1310.             }
  1311.             if(_loc18_ > 0)
  1312.             {
  1313.                textField.width = _loc4_ = Math.max(_loc24_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,0);
  1314.             }
  1315.             else
  1316.             {
  1317.                textField.width = _loc4_ = 0;
  1318.             }
  1319.             textField.height = _loc5_ = Math.min(_loc25_ + 2,_loc19_ + UITextField.mx_internal::TEXT_HEIGHT_PADDING);
  1320.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  1321.             {
  1322.                _loc6_ = _loc8_ + _loc12_;
  1323.                if(mx_internal::centerContent)
  1324.                {
  1325.                   if(_loc22_ == "left")
  1326.                   {
  1327.                      _loc6_ += _loc14_;
  1328.                   }
  1329.                   else if(_loc22_ == "right")
  1330.                   {
  1331.                      _loc6_ += _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc14_;
  1332.                   }
  1333.                   else
  1334.                   {
  1335.                      _loc28_ = (_loc24_ - _loc4_ - _loc8_ - _loc12_) / 2;
  1336.                      _loc6_ += Math.max(_loc28_,_loc14_);
  1337.                   }
  1338.                }
  1339.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  1340.                if(!mx_internal::centerContent)
  1341.                {
  1342.                   _loc6_ += _loc14_;
  1343.                }
  1344.             }
  1345.             else
  1346.             {
  1347.                _loc6_ = _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  1348.                if(mx_internal::centerContent)
  1349.                {
  1350.                   if(_loc22_ == "left")
  1351.                   {
  1352.                      _loc6_ = 2;
  1353.                   }
  1354.                   else if(_loc22_ == "right")
  1355.                   {
  1356.                      _loc6_--;
  1357.                   }
  1358.                   else if(_loc6_ > 0)
  1359.                   {
  1360.                      _loc6_ /= 2;
  1361.                   }
  1362.                }
  1363.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  1364.             }
  1365.             _loc11_ = _loc7_ = 0;
  1366.             if(mx_internal::centerContent)
  1367.             {
  1368.                _loc11_ = Math.round((_loc25_ - _loc9_) / 2) + _loc16_;
  1369.                _loc7_ = Math.round((_loc25_ - _loc5_) / 2) + _loc16_;
  1370.             }
  1371.             else
  1372.             {
  1373.                _loc7_ += Math.max(0,(_loc25_ - _loc5_) / 2) + _loc16_;
  1374.                _loc11_ += Math.max(0,(_loc25_ - _loc9_) / 2 - 1) + _loc16_;
  1375.             }
  1376.          }
  1377.          else
  1378.          {
  1379.             _loc13_ = getStyle("verticalGap");
  1380.             if(_loc9_ == 0 || _loc19_ == 0)
  1381.             {
  1382.                _loc13_ = 0;
  1383.             }
  1384.             if(_loc18_ > 0)
  1385.             {
  1386.                textField.width = _loc4_ = Math.min(_loc24_,_loc18_ + UITextField.mx_internal::TEXT_WIDTH_PADDING);
  1387.                textField.height = _loc5_ = Math.min(_loc25_ - _loc9_ + 1,_loc19_ + 5);
  1388.             }
  1389.             else
  1390.             {
  1391.                textField.width = _loc4_ = 0;
  1392.                textField.height = _loc5_ = 0;
  1393.             }
  1394.             _loc6_ = (_loc24_ - _loc4_) / 2;
  1395.             _loc10_ = (_loc24_ - _loc8_) / 2;
  1396.             if(labelPlacement == ButtonLabelPlacement.TOP)
  1397.             {
  1398.                _loc7_ = _loc25_ - _loc5_ - _loc9_ - _loc13_;
  1399.                if(mx_internal::centerContent && _loc7_ > 0)
  1400.                {
  1401.                   _loc7_ /= 2;
  1402.                }
  1403.                _loc7_ += _loc16_;
  1404.                _loc11_ = _loc7_ + _loc5_ + _loc13_ - 3;
  1405.             }
  1406.             else
  1407.             {
  1408.                _loc7_ = _loc9_ + _loc13_ + _loc16_;
  1409.                if(mx_internal::centerContent)
  1410.                {
  1411.                   _loc7_ += (_loc25_ - _loc5_ - _loc9_ - _loc13_) / 2 + 1;
  1412.                }
  1413.                _loc11_ = _loc7_ - _loc9_ - _loc13_ + 3;
  1414.             }
  1415.          }
  1416.          var _loc26_:Number = _loc21_;
  1417.          var _loc27_:Number = _loc21_;
  1418.          if(_loc23_)
  1419.          {
  1420.             _loc26_ += _loc23_.left;
  1421.             _loc27_ += _loc23_.top;
  1422.          }
  1423.          textField.x = _loc6_ + _loc26_;
  1424.          textField.y = _loc7_ + _loc27_;
  1425.          if(mx_internal::currentIcon)
  1426.          {
  1427.             _loc10_ += _loc26_;
  1428.             _loc11_ += _loc27_;
  1429.             _loc29_ = new MoveEvent(MoveEvent.MOVE);
  1430.             _loc29_.oldX = mx_internal::currentIcon.x;
  1431.             _loc29_.oldY = mx_internal::currentIcon.y;
  1432.             mx_internal::currentIcon.x = Math.round(_loc10_);
  1433.             mx_internal::currentIcon.y = Math.round(_loc11_);
  1434.             mx_internal::currentIcon.dispatchEvent(_loc29_);
  1435.          }
  1436.          if(mx_internal::currentSkin)
  1437.          {
  1438.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  1439.          }
  1440.          if(mx_internal::currentIcon)
  1441.          {
  1442.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  1443.          }
  1444.          if(textField)
  1445.          {
  1446.             setChildIndex(DisplayObject(textField),numChildren - 1);
  1447.          }
  1448.       }
  1449.       
  1450.       private function systemManager_mouseUpHandler(param1:MouseEvent) : void
  1451.       {
  1452.          if(contains(DisplayObject(param1.target)))
  1453.          {
  1454.             return;
  1455.          }
  1456.          mx_internal::phase = ButtonPhase.UP;
  1457.          mx_internal::buttonReleased();
  1458.          param1.updateAfterEvent();
  1459.       }
  1460.       
  1461.       public function set label(param1:String) : void
  1462.       {
  1463.          labelSet = true;
  1464.          if(_label != param1)
  1465.          {
  1466.             _label = param1;
  1467.             labelChanged = true;
  1468.             invalidateSize();
  1469.             invalidateDisplayList();
  1470.             dispatchEvent(new Event("labelChanged"));
  1471.          }
  1472.       }
  1473.       
  1474.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1475.       {
  1476.          var _loc5_:IFlexDisplayObject = null;
  1477.          var _loc6_:Boolean = false;
  1478.          super.updateDisplayList(param1,param2);
  1479.          if(emphasizedChanged)
  1480.          {
  1481.             mx_internal::changeSkins();
  1482.             emphasizedChanged = false;
  1483.          }
  1484.          var _loc3_:int = int(skins.length);
  1485.          var _loc4_:int = 0;
  1486.          while(_loc4_ < _loc3_)
  1487.          {
  1488.             _loc5_ = IFlexDisplayObject(skins[_loc4_]);
  1489.             _loc5_.setActualSize(param1,param2);
  1490.             _loc4_++;
  1491.          }
  1492.          mx_internal::viewSkin();
  1493.          mx_internal::viewIcon();
  1494.          mx_internal::layoutContents(param1,param2,mx_internal::phase == ButtonPhase.DOWN);
  1495.          if(oldUnscaledWidth > param1 || textField.text != label || labelChanged || styleChangedFlag)
  1496.          {
  1497.             textField.text = label;
  1498.             _loc6_ = textField.truncateToFit();
  1499.             if(!toolTipSet)
  1500.             {
  1501.                if(_loc6_)
  1502.                {
  1503.                   super.toolTip = label;
  1504.                }
  1505.                else
  1506.                {
  1507.                   super.toolTip = null;
  1508.                }
  1509.             }
  1510.             styleChangedFlag = false;
  1511.             labelChanged = false;
  1512.          }
  1513.          oldUnscaledWidth = param1;
  1514.       }
  1515.       
  1516.       private function stage_mouseLeaveHandler(param1:Event) : void
  1517.       {
  1518.          mx_internal::phase = ButtonPhase.UP;
  1519.          mx_internal::buttonReleased();
  1520.       }
  1521.       
  1522.       public function set listData(param1:BaseListData) : void
  1523.       {
  1524.          _listData = param1;
  1525.       }
  1526.    }
  1527. }
  1528.  
  1529.